import express from 'express'
import cors from 'cors'
import bodyParser from 'body-parser'
import { Sequelize, DataTypes, Op } from 'sequelize'
import fs from 'fs'
import path from 'path'
import { fileURLToPath } from 'url'
import os from 'os'
import { EventEmitter } from 'events'
import multer from 'multer'
import { encryptPassword, decryptPassword } from './crypto.js'
import jwt from 'jsonwebtoken'
const __filename = fileURLToPath(import.meta.url)
const __dirname = path.dirname(__filename)

// 初始化Express应用
const app = express()
app.use(cors())

// 只对非multipart请求应用bodyParser
app.use((req, res, next) => {
  if (req.headers['content-type'] && req.headers['content-type'].includes('multipart/form-data')) {
    // 跳过multipart请求的body解析
    next()
  } else {
    // 对非multipart请求应用bodyParser
    bodyParser.json({ limit: '1mb' })(req, res, next)
  }
})

// 文件上传配置
const UPLOAD_DIR = path.join(__dirname, '../uploads')
const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50MB
const ALLOWED_FILE_TYPES = [
  'image/jpeg', 'image/png', 'image/gif', 'image/webp',
  'application/pdf', 'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
  'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
  'text/plain', 'text/csv', 'application/zip', 'application/x-rar-compressed'
]

// 确保上传目录存在
if (!fs.existsSync(UPLOAD_DIR)) {
  fs.mkdirSync(UPLOAD_DIR, { recursive: true })
}

// 配置 multer 存储
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    // 根据文件类型创建子目录，使用更智能的分类
    let fileType = 'other'

    if (file.mimetype.startsWith('image/')) {
      fileType = 'image'
    } else if (file.mimetype.startsWith('application/')) {
      fileType = 'application'
    } else if (file.mimetype.startsWith('text/')) {
      fileType = 'text'
    } else if (file.mimetype.startsWith('video/')) {
      fileType = 'video'
    } else if (file.mimetype.startsWith('audio/')) {
      fileType = 'audio'
    }

    const subDir = path.join(UPLOAD_DIR, fileType)
    if (!fs.existsSync(subDir)) {
      fs.mkdirSync(subDir, { recursive: true })
    }
    cb(null, subDir)
  },
  filename: (req, file, cb) => {
    // 生成唯一文件名：时间戳 + 随机数 + 原扩展名
    const timestamp = Date.now()
    const random = Math.random().toString(36).substring(2, 15)
    const ext = path.extname(file.originalname)
    const filename = `${timestamp}_${random}${ext}`
    cb(null, filename)
  }
})

// 文件过滤器
const fileFilter = (req, file, cb) => {
  if (ALLOWED_FILE_TYPES.includes(file.mimetype)) {
    cb(null, true)
  } else {
    cb(new Error(`不支持的文件类型: ${file.mimetype}`), false)
  }
}

// 配置 multer
const upload = multer({
  storage: storage,
  fileFilter: fileFilter,
  limits: {
    fileSize: MAX_FILE_SIZE,
    files: 10 // 最多10个文件
  }
})

// 静态文件服务 - 添加MIME类型支持
app.use('/uploads', express.static(UPLOAD_DIR, {
  setHeaders: (res, path, stat) => {
    // 根据文件扩展名设置正确的Content-Type
    const ext = path.extname(path).toLowerCase()
    const mimeTypes = {
      '.pdf': 'application/pdf',
      '.doc': 'application/msword',
      '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
      '.xls': 'application/vnd.ms-excel',
      '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
      '.txt': 'text/plain',
      '.csv': 'text/csv',
      '.zip': 'application/zip',
      '.rar': 'application/x-rar-compressed',
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.png': 'image/png',
      '.gif': 'image/gif',
      '.webp': 'image/webp'
    }

    if (mimeTypes[ext]) {
      res.set('Content-Type', mimeTypes[ext])
    }

    // 设置下载头，确保文件能正确下载
    res.set('Content-Disposition', 'inline')
  }
}))

// 添加更详细的日志记录
const logRequest = (req, res, next) => {
  const start = Date.now()
  const { method, url, ip } = req

  console.log(`[${new Date().toISOString()}] ${method} ${url} - 开始处理 - IP: ${ip}`)

  // 只对非multipart请求记录请求体
  if (req.headers['content-type'] && !req.headers['content-type'].includes('multipart/form-data')) {
    console.log(`请求体:`, JSON.stringify(req.body, null, 2))
  } else if (req.headers['content-type'] && req.headers['content-type'].includes('multipart/form-data')) {
    console.log(`文件上传请求 - Content-Type: ${req.headers['content-type']}`)
  }

  // 捕获响应完成事件
  res.on('finish', () => {
    const duration = Date.now() - start
    const status = res.statusCode
    console.log(`[${new Date().toISOString()}] ${method} ${url} - ${status} - ${duration}ms - IP: ${ip}`)
  })

  next()
}

// 应用日志中间件
app.use(logRequest)

// 添加超时中间件
app.use((req, res, next) => {
  // 设置更长的超时，例如10秒
  req.setTimeout(10000, () => {
    res.status(408).json({ error: '请求超时' });
  });
  next();
});

// 添加简单的速率限制中间件
const requestCounts = new Map()
const RATE_LIMIT_WINDOW = 60 * 1000 // 1分钟
const RATE_LIMIT_MAX = 1000 // 每个IP每分钟最多100个请求

app.use((req, res, next) => {
  const ip = req.ip
  const now = Date.now()

  // 清理过期的请求计数
  if (!requestCounts.has(ip)) {
    requestCounts.set(ip, {
      count: 0,
      resetTime: now + RATE_LIMIT_WINDOW
    })
  } else {
    const record = requestCounts.get(ip)
    if (now > record.resetTime) {
      record.count = 0
      record.resetTime = now + RATE_LIMIT_WINDOW
    }
  }

  // 检查请求计数
  const record = requestCounts.get(ip)
  record.count++

  if (record.count > RATE_LIMIT_MAX) {
    return res.status(429).json({
      error: '请求过于频繁，请稍后再试',
      retryAfter: Math.ceil((record.resetTime - now) / 1000)
    })
  }

  next()
})

// 加载配置
let config = {
  databaseType: 'sqlite', // 当前使用的数据库类型
  databaseConfig: {
    sqlite: {
      type: 'sqlite',
      storage: path.join(__dirname, '../database.sqlite')
    },
    mysql: {
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      user: 'root',
      password: '',
      database: 'admin_app'
    },
    mssql: {
      type: 'mssql',
      host: 'localhost',
      port: 1433,
      user: 'sa',
      password: '',
      database: 'admin_app',
      options: {
        encrypt: true
      }
    }
  },

  // 获取当前数据库配置的辅助方法
  getCurrentDatabaseConfig() {
    return this.databaseConfig[this.databaseType];
  },

  // 更新数据库配置的方法
  updateDatabaseConfig(type, newConfig) {
    if (!this.databaseConfig[type]) {
      throw new Error(`不支持的数据库类型: ${type}`);
    }
    this.databaseConfig[type] = {
      ...this.databaseConfig[type],
      ...newConfig,
      type // 确保类型不被覆盖
    };
  }
};

// 确保配置文件存在
const configPath = path.join(__dirname, 'config.json');
try {
  if (fs.existsSync(configPath)) {
    const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
    config = {
      ...config,
      ...savedConfig,
      // 保持方法不被覆盖
      getCurrentDatabaseConfig: config.getCurrentDatabaseConfig,
      updateDatabaseConfig: config.updateDatabaseConfig
    };
  }
} catch (error) {
  console.error('加载配置文件失败:', error);
}

// 保存配置到文件的函数
function saveConfig() {
  try {
    // 创建一个不包含方法的配置副本
    const configToSave = {
      databaseType: config.databaseType,
      databaseConfig: config.databaseConfig
    };
    fs.writeFileSync(configPath, JSON.stringify(configToSave, null, 2));
  } catch (error) {
    console.error('保存配置文件失败:', error);
  }
}

// 获取数据库方言配置
function getDialectConfig(dbConfig) {
  const baseConfig = {
    logging: false,
    define: {
      // 禁用 Sequelize 的自动时间戳
      timestamps: false,
      // 禁用外键约束检查
      foreignKeys: false
    }
  };

  switch (dbConfig.type) {
    case 'mysql':
      return {
        ...baseConfig,
        dialect: 'mysql',
        host: dbConfig.host,
        port: dbConfig.port || 3306,
        username: dbConfig.user,
        password: dbConfig.password,
        database: dbConfig.database,
        dialectOptions: {
          charset: 'utf8mb4'
        }
      };
    case 'sqlite':
      return {
        ...baseConfig,
        dialect: 'sqlite',
        storage: dbConfig.storage
      };
    case 'mssql':
      return {
        ...baseConfig,
        dialect: 'mssql',
        host: dbConfig.host,
        port: dbConfig.port || 1433,
        username: dbConfig.user,
        password: dbConfig.password,
        database: dbConfig.database,
        dialectOptions: {
          options: {
            trustServerCertificate: true
          }
        }
      };
    default:
      throw new Error(`不支持的数据库类型: ${dbConfig.type}`);
  }
}

// 创建数据库连接
async function createSequelizeInstance(config) {
  const sequelize = new Sequelize(getDialectConfig(config));

  // 根据数据库类型执行特定的初始化
  if (config.type === 'sqlite') {
    // SQLite 特有的初始化
    await sequelize.query('PRAGMA foreign_keys = ON');
  }

  return sequelize;
}

// 处理日期时间格式
function formatDateTime(value) {
  if (!value) return 'NULL';
  try {
    // 移除多余的引号
    const dateStr = value.replace(/['"]/g, '');
    const date = new Date(dateStr);
    // 格式化为 MySQL 标准格式
    return `'${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}'`;
  } catch (error) {
    console.error('日期格式化错误:', error);
    return 'NULL';
  }
}

// 获取表中的现有记录
async function getExistingRecords(sequelize, tableName, config) {
  try {
    const [results] = await sequelize.query(
      config.type === 'mysql'
        ? `SELECT * FROM \`${tableName}\``
        : `SELECT * FROM "${tableName}"`
    );
    return results;
  } catch (error) {
    console.error('获取现有记录时出错:', error);
    return [];
  }
}

// 检查表是否存在
async function tableExists(sequelize, tableName, config) {
  try {
    if (config.type === 'mysql') {
      const [results] = await sequelize.query(`
        SELECT TABLE_NAME 
        FROM information_schema.TABLES 
        WHERE TABLE_SCHEMA = '${config.database}' 
        AND TABLE_NAME = '${tableName}'
      `);
      return results.length > 0;
    } else if (config.type === 'sqlite') {
      const [results] = await sequelize.query(`
        SELECT name FROM sqlite_master 
        WHERE type='table' AND name = '${tableName}'
      `);
      return results.length > 0;
    }
    return false;
  } catch (error) {
    console.error('检查表是否存在时出错:', error);
    return false;
  }
}

// 修改数据迁移函数
async function migrateDatabaseData(oldConfig, newConfig) {
  console.log('开始数据迁移...');
  console.log('源配置:', oldConfig);
  console.log('目标配置:', newConfig);

  try {
    // 获取源数据库和目标数据库的配置
    const sourceDialect = getDialectConfig({
      type: oldConfig.type,
      ...oldConfig[oldConfig.type]
    });

    const targetDialect = getDialectConfig({
      type: newConfig.type,
      ...newConfig[newConfig.type]
    });

    console.log('源数据库配置:', sourceDialect);
    console.log('目标数据库配置:', targetDialect);

    // ... 后续迁移逻辑 ...

  } catch (error) {
    console.error('数据同步失败:', error);
    throw error;
  }
}

// 获取设置接口
app.get('/api/settings', (req, res) => {
  res.json({
    databaseType: config.databaseType,
    databaseConfig: config.databaseConfig
  });
});

// 添加重新加载配置的函数
async function reloadConfiguration() {
  try {
    console.log('正在重新加载配置...');

    // 重新加载配置文件
    if (fs.existsSync(configPath)) {
      const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
      config = {
        ...config,
        ...savedConfig,
        // 保持方法不被覆盖
        getCurrentDatabaseConfig: config.getCurrentDatabaseConfig,
        updateDatabaseConfig: config.updateDatabaseConfig
      };
    }
  } catch (error) {
    console.error('重新加载配置失败:', error);
    throw error;
  }
}

// 修改设置接口
app.post('/api/settings', async (req, res) => {
  try {
    console.log('POST /api/settings - 开始处理');
    console.log('请求体:', req.body);

    const { databaseType, databaseConfig } = req.body;

    // 验证参数
    if (!databaseType || !databaseConfig) {
      throw new Error('缺少必要的配置参数');
    }

    // 获取当前配置
    const oldConfig = {
      type: config.databaseType,
      sqlite: databaseConfig.sqlite,
      mysql: databaseConfig.mysql,
      sqlserver: databaseConfig.sqlserver
    };

    // 准备新配置对象，保持与请求体相同的结构
    const newConfig = {
      type: databaseType,
      sqlite: databaseConfig.sqlite,
      mysql: databaseConfig.mysql,
      sqlserver: databaseConfig.sqlserver
    };

    console.log('当前配置:', oldConfig);
    console.log('新配置:', newConfig);

    // 执行迁移
    await migrateDatabaseData(oldConfig, newConfig);

    // 更新配置
    config.databaseType = databaseType;
    config.databaseConfig = databaseConfig;

    // 保存配置
    saveConfig();

    // 重新加载配置
    await reloadConfiguration();

    res.json({
      success: true,
      config: {
        databaseType,
        databaseConfig
      },
      message: '设置已更新并完成配置重载'
    });

  } catch (error) {
    console.error('更新设置失败:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '更新设置失败: ' + error.message
    });
  }
});

// 初始化数据库连接
let sequelize
switch (config.databaseType) {
  case 'mysql':
    sequelize = new Sequelize(
      config.databaseConfig.mysql.database,
      config.databaseConfig.mysql.username,
      config.databaseConfig.mysql.password,
      {
        host: config.databaseConfig.mysql.host,
        port: config.databaseConfig.mysql.port,
        dialect: 'mysql',
        logging: console.log
      }
    )
    break
  case 'sqlserver':
    sequelize = new Sequelize(
      config.databaseConfig.sqlserver.database,
      config.databaseConfig.sqlserver.user,
      config.databaseConfig.sqlserver.password,
      {
        host: config.databaseConfig.sqlserver.server,
        port: config.databaseConfig.sqlserver.port,
        dialect: 'mssql',
        logging: console.log
      }
    )
    break
  case 'sqlite':
  default:
    sequelize = new Sequelize({
      dialect: 'sqlite',
      storage: config.databaseConfig.sqlite.storage,
      logging: console.log,
      retry: {
        max: 1, // 增加最大重试次数
        match: [
          /SQLITE_BUSY/,  // 数据库锁定时重试
          /SQLITE_LOCKED/ // 表被锁定时重试
        ],
        backoffBase: 30000, // 重试间隔基数(毫秒)
        backoffExponent: 1.5 // 重试间隔指数
      },
      pool: {
        max: 5,
        min: 0,
        acquire: 60000, // 增加获取连接超时时间
        idle: 10000
      },
      transactionType: 'IMMEDIATE' // 使用立即事务模式
    })
    break
}

// 确保在数据库初始化时设置 WAL 模式
//await sequelize.query('PRAGMA journal_mode=WAL;');
//await sequelize.query('PRAGMA busy_timeout = 6000;'); // 设置忙等待超时为6秒

// 定义模型表
const Model = sequelize.define('Model', {
  name: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      notEmpty: true
    }
  },
  displayName: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notEmpty: true
    }
  },
  description: {
    type: DataTypes.TEXT,
    allowNull: true
  },
  fields: {
    type: DataTypes.JSON,
    allowNull: false,
    defaultValue: []
  }
})

// 定义设置表
const Setting = sequelize.define('Setting', {
  key: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    primaryKey: true
  },
  value: {
    type: DataTypes.JSON,
    allowNull: true
  }
})

// 定义授权IP表
const AuthorizedIP = sequelize.define('AuthorizedIP', {
  ip: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isIP: true
    }
  },
  description: {
    type: DataTypes.STRING,
    allowNull: true
  },
  enabled: {
    type: DataTypes.BOOLEAN,
    defaultValue: true
  },
  lastAccess: {
    type: DataTypes.DATE,
    allowNull: true
  }
});

// 添加IP授权缓存
let authorizedIPCache = new Map();

// 重新加载IP授权缓存
async function reloadIPAuthorization() {
  try {
    console.log('正在重新加载IP授权配置...');

    // 清空现有缓存
    const oldSize = authorizedIPCache.size;
    authorizedIPCache.clear();

    // 从数据库加载所有启用的IP
    const authorizedIPs = await AuthorizedIP.findAll({
      where: {
        enabled: true
      }
    });

    // 更新缓存
    authorizedIPs.forEach(ip => {
      authorizedIPCache.set(ip.ip, {
        id: ip.id,
        description: ip.description,
        lastAccess: ip.lastAccess
      });
    });

    console.log(`IP授权配置已重新加载:`);
    console.log(`- 原缓存数量: ${oldSize}`);
    console.log(`- 新缓存数量: ${authorizedIPCache.size}`);
    console.log(`- 已启用的IP列表:`);
    authorizedIPs.forEach(ip => {
      console.log(`  * ${ip.ip} (${ip.description || '无描述'})`);
    });

    return true;
  } catch (error) {
    console.error('重新加载IP授权配置失败:', error);
    throw error;
  }
}

// IP授权检查中间件
const checkIPAuthorization = async (req, res, next) => {
  if (req.path.startsWith('/api/auth')) {
    return next();
  }

  // 修改获取真实IP的逻辑
  const realIP = req.socket.remoteAddress;

  console.log(`\n=== IP授权检查 ===`);
  console.log(`请求信息:`);
  console.log(`- 真实IP: ${realIP}`);
  console.log(`- 路径: ${req.path}`);
  console.log(`- 方法: ${req.method}`);
  console.log(`- Socket信息:`, {
    remoteAddress: req.socket.remoteAddress,
    remoteFamily: req.socket.remoteFamily
  });

  // 如果是本地IP，直接放行
  if (isLocalIP(realIP)) {
    console.log(`本地IP直接放行: ${realIP}`);
    console.log('=== 检查结束 ===\n');
    return next();
  }

  try {
    // 先查询IP是否在授权列表中（不管状态）
    let authorizedIP = await AuthorizedIP.findOne({
      where: { ip: realIP }
    });
    if (!authorizedIP) {
      await AuthorizedIP.create({
        ip: realIP,
        enabled: true,
        lastAccess: new Date()
      })
      authorizedIP = await AuthorizedIP.findOne({
        where: { ip: realIP }
      });
    }

    // 如果IP未配置或状态为false，拒绝访问
    if (!authorizedIP || !authorizedIP.enabled) {
      const reason = !authorizedIP ? '未配置授权' : '授权已禁用';
      console.log(`拒绝访问:`);
      console.log(`- IP: ${realIP}`);
      console.log(`- 原因: ${reason}`);
      console.log('=== 检查结束 ===\n');

      return res.status(403).json({
        error: `IP访问被拒绝 - ${reason}`,
        code: 'UNAUTHORIZED_IP',
        ip: realIP,
        status: !authorizedIP ? 'unconfigured' : 'disabled'
      });
    }

    // IP已授权且状态为enabled，更新访问时间
    await authorizedIP.update({ lastAccess: new Date() });

    console.log(`授权IP访问成功:`);
    console.log(`- IP: ${realIP}`);
    console.log('=== 检查结束 ===\n');

    next();
  } catch (error) {
    console.error('IP授权检查失败:', error);
    res.status(500).json({
      error: 'IP授权检查失败',
      code: 'CHECK_ERROR'
    });
  }
};

// 修改日志中间件
app.use((req, res, next) => {
  const start = Date.now();
  const realIP = req.socket.remoteAddress;

  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url} - ${res.statusCode} - ${duration}ms - IP: ${realIP}`);
  });

  next();
});

// 获取本地IP地址的函数
function getLocalIPs() {
  const networkInterfaces = os.networkInterfaces();
  const ips = new Set(['::1', '127.0.0.1', 'localhost']);

  Object.values(networkInterfaces).forEach(interfaces => {
    interfaces.forEach(iface => {
      if (!iface.internal) {
        ips.add(iface.address);
      }
    });
  });

  return ips;
}

// 初始化IP授权状态
async function initializeAuthStatus() {
  try {
    // 确保表已创建
    await AuthorizedIP.sync();

    // 获取所有已授权的IP
    const authorizedIPs = await AuthorizedIP.findAll({
      where: {
        enabled: true
      }
    });

    // 更新缓存
    authorizedIPCache.clear();
    authorizedIPs.forEach(ip => {
      authorizedIPCache.set(ip.ip, {
        id: ip.id,
        description: ip.description,
        lastAccess: ip.lastAccess
      });
    });

    console.log(`已加载 ${authorizedIPCache.size} 个授权IP`);
    return true;
  } catch (error) {
    console.error('初始化IP授权状态失败:', error);
    throw error;
  }
}

// 应用中间件 - 注意顺序很重要
app.use(cors());
app.use(logRequest);

// 在其他路由之前应用IP授权检查中间件
app.use('/api', checkIPAuthorization);

// 添加一个简单的事件发布/订阅系统
const authEvents = new EventEmitter();

// 全局授权状态
let authorizedIPsStatus = new Map();

// 监听授权状态变更事件
authEvents.on('auth-status-changed', async () => {
  await initializeAuthStatus();
});

// 添加本地IP检查函数
function isLocalIP(ip) {
  const localIPs = new Set([
    '127.0.0.1',
    '::1',
    'localhost',
    '::ffff:127.0.0.1'
    , '0.0.0.0'
  ]);
  return localIPs.has(ip);
}

// 添加一个简单的测试端点
app.get('/api/test-auth', (req, res) => {
  res.json({
    message: '如果你看到这个消息，说明你的IP已经通过授权检查',
    timestamp: new Date().toISOString()
  });
});

// IP授权管理API
// 获取所有授权IP
app.get('/api/auth/ips', async (req, res) => {
  try {
    console.log('获取授权IP列表');
    const ips = await AuthorizedIP.findAll({
      order: [['lastAccess', 'DESC']]
    });

    console.log('查询结果:', ips.length ? ips : '无授权IP');
    res.json(ips);
  } catch (error) {
    console.error('获取授权IP列表失败:', error);
    res.status(500).json({
      error: '获取授权IP列表失败',
      message: error.message
    });
  }
});

// 添加授权IP
app.post('/api/auth/ips', async (req, res) => {
  const transaction = await sequelize.transaction();
  try {
    const { ip, description } = req.body;
    console.log('添加授权IP请求:', { ip, description });

    if (!ip) {
      return res.status(400).json({
        error: 'IP地址不能为空'
      });
    }

    // 检查IP是否已存在
    const existingIP = await AuthorizedIP.findOne({
      where: { ip },
      transaction
    });

    if (existingIP) {
      await transaction.rollback();
      return res.status(409).json({
        error: 'IP地址已存在'
      });
    }

    const authorizedIP = await AuthorizedIP.create({
      ip,
      description,
      enabled: true,
      lastAccess: null
    }, { transaction });

    await transaction.commit();

    console.log(`新增IP授权成功 - IP: ${ip}, 描述: ${description}`);

    res.status(201).json({
      success: true,
      data: authorizedIP,
      message: `IP ${ip} 已添加到授权列表`
    });
  } catch (error) {
    await transaction.rollback();
    console.error('添加授权IP失败:', error);
    res.status(500).json({
      error: '添加授权IP失败',
      message: error.message
    });
  }
});

// 更新授权IP
app.put('/api/auth/ips/:id', async (req, res) => {
  const transaction = await sequelize.transaction();
  try {
    const { id } = req.params;
    const { enabled, description } = req.body;

    console.log(`更新IP授权请求 - ID: ${id}`, { enabled, description });

    const authorizedIP = await AuthorizedIP.findByPk(id, { transaction });
    if (!authorizedIP) {
      await transaction.rollback();
      return res.status(404).json({
        error: '授权IP不存在'
      });
    }

    await authorizedIP.update({
      enabled: enabled !== undefined ? enabled : authorizedIP.enabled,
      description: description || authorizedIP.description
    }, { transaction });

    await transaction.commit();

    console.log(`IP授权更新成功 - IP: ${authorizedIP.ip}, 启用状态: ${enabled}`);

    res.json({
      success: true,
      data: authorizedIP,
      message: `IP ${authorizedIP.ip} 已${enabled ? '启用' : '禁用'}授权`
    });
  } catch (error) {
    await transaction.rollback();
    console.error('更新授权IP失败:', error);
    res.status(500).json({
      error: '更新授权IP失败',
      message: error.message
    });
  }
});

// 删除授权IP
app.delete('/api/auth/ips/:id', async (req, res) => {
  const transaction = await sequelize.transaction();
  try {
    const { id } = req.params;
    console.log(`删除IP授权请求 - ID: ${id}`);

    const authorizedIP = await AuthorizedIP.findByPk(id, { transaction });
    if (!authorizedIP) {
      await transaction.rollback();
      return res.status(404).json({
        error: '授权IP不存在'
      });
    }

    const ipAddress = authorizedIP.ip;
    await authorizedIP.destroy({ transaction });
    await transaction.commit();

    console.log(`删除IP授权成功 - IP: ${ipAddress}`);

    res.json({
      success: true,
      message: `IP ${ipAddress} 已从授权列表中删除`
    });
  } catch (error) {
    await transaction.rollback();
    console.error('删除授权IP失败:', error);
    res.status(500).json({
      error: '删除授权IP失败',
      message: error.message
    });
  }
});

// 存储动态模型
const dynamicModels = {}

// 初始化数据库
async function initDatabase() {
  try {
    console.log('正在初始化数据库...')
    await sequelize.authenticate()
    console.log('数据库连接成功')

    // 同步模型表
    await Model.sync()
    console.log('模型表同步完成')

    // 同步设置表
    await Setting.sync()
    console.log('设置表同步完成')

    // 同步授权IP表
    await AuthorizedIP.sync()
    console.log('授权IP表同步完成')

    // 初始化设置
    const databaseSettings = await Setting.findOne({ where: { key: 'database' } })
    if (!databaseSettings) {
      await Setting.create({
        key: 'database',
        value: {
          type: config.databaseType,
          config: config.databaseConfig
        }
      })
      console.log('数据库设置初始化完成')
    }
  } catch (error) {
    console.error('数据库初始化失败:', error)
    throw error
  }
}

// 根据字段类型获取Sequelize数据类型
function getSequelizeType(fieldType) {
  switch (fieldType) {
    case 'string':
      return DataTypes.STRING
    case 'text':
      return DataTypes.TEXT
    case 'integer':
      return DataTypes.INTEGER
    case 'float':
      return DataTypes.FLOAT
    case 'boolean':
      return DataTypes.BOOLEAN
    case 'date':
      return DataTypes.DATEONLY
    case 'datetime':
      return DataTypes.DATE
    case 'json':
      return DataTypes.JSON
    default:
      return DataTypes.STRING
  }
}

// 创建动态模型
function createDynamicModel(modelDef) {
  console.log(`创建动态模型: ${modelDef.name}`)

  // 定义字段
  const fields = {}

  // 添加ID字段
  fields.id = {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true
  }

  // 添加自定义字段
  for (const field of modelDef.fields) {
    fields[field.name] = {
      type: getSequelizeType(field.type),
      allowNull: !field.required,
      defaultValue: field.defaultValue !== undefined ? field.defaultValue : null
    }
  }

  // 添加创建时间和更新时间
  fields.createdAt = {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW
  }

  fields.updatedAt = {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW
  }

  // 定义模型
  const dynamicModel = sequelize.define(modelDef.name, fields, {
    tableName: `data_${modelDef.name}`,
    timestamps: true
  })

  // 存储模型
  dynamicModels[modelDef.name] = dynamicModel

  return dynamicModel
}

// 创建并同步动态模型
async function createAndSyncDynamicModel(modelDef) {
  try {
    console.log(`创建动态模型: ${modelDef.name}`)

    // 确保modelDef.fields是数组
    let fields = []
    console.log(1)
    try {
      if (Array.isArray(modelDef.fields)) {
        fields = modelDef.fields
      } else if (typeof modelDef.fields === 'string') {
        fields = JSON.parse(modelDef.fields)
      }
    } catch (err) {
      console.error(`解析${modelDef.name}模型字段失败:`, err)
      throw new Error('字段解析失败')
    }
    console.log(2)
    // 检查模型是否已存在
    if (dynamicModels[modelDef.name]) {
      console.log(`模型 ${modelDef.name} 已存在，跳过创建`)
      return dynamicModels[modelDef.name]
    }
    console.log(3)
    // 创建模型定义
    const modelAttributes = {}

    // 添加ID字段
    modelAttributes.id = {
      type: DataTypes.STRING,
      primaryKey: true,

    }

    // 添加其他字段
    for (const field of fields) {
      let fieldType
      switch (field.type) {
        case 'string':
        case 'text':
          fieldType = DataTypes.STRING
          break
        case 'integer':
          fieldType = DataTypes.INTEGER
          break
        case 'number':
        case 'float':
          fieldType = DataTypes.FLOAT
          break
        case 'boolean':
          fieldType = DataTypes.BOOLEAN
          break
        case 'date':
          fieldType = DataTypes.DATEONLY
          break
        case 'json':
          fieldType = DataTypes.JSON
          break
        case 'datetime':
          fieldType = DataTypes.DATE
          break
        default:
          throw new Error(`不支持的字段类型: ${field.type}`)
      }
      console.log(4)
      modelAttributes[field.name] = {
        type: fieldType,
        allowNull: !field.required
      }
    }
    console.log(5)
    // 添加时间戳字段
    modelAttributes.createdAt = {
      type: DataTypes.DATE,
      defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
    }

    modelAttributes.updatedAt = {
      type: DataTypes.DATE,
      defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
    }
    console.log(6)
    // 创建模型
    const model = sequelize.define(modelDef.name, modelAttributes, {
      tableName: modelDef.name,
      timestamps: true,
      // 设置更长的查询超时时间
      dialectOptions: {
        timeout: 30000 // 30秒超时
      }
    })
    console.log(7)
    try {
      // 使用锁机制来确保原子性
      //await sequelize.transaction({ isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE }, async (t) => {
      console.log(`开始同步模型: ${modelDef.name}`)
      await model.sync({ alter: true }) // 使用alter选项
      console.log(`模型同步完成: ${modelDef.name}`)
      //})
      console.log(8)
      // 存储模型定义
      dynamicModels[modelDef.name] = model
      console.log(`动态模型创建成功: ${modelDef.name}`)
      console.log(9)
      return model
    } catch (syncError) {
      console.log(-8)
      console.error(`同步模型失败: ${modelDef.name}`, syncError)
      throw syncError
    }
  } catch (err) {
    console.log(-8)
    console.error(`创建动态模型失败: ${modelDef.name}`, err)
    throw err
  }
}

// 加载所有模型
async function loadModels() {
  try {
    console.log('正在加载模型...')
    const models = await Model.findAll()
    console.log(`找到 ${models.length} 个模型`)

    for (const model of models) {
      try {
        await createAndSyncDynamicModel(model)
      } catch (error) {
        console.error(`加载模型 ${model.name} 失败:`, error)
      }
    }

    console.log('所有模型加载完成')
  } catch (error) {
    console.error('加载模型失败:', error)
    throw error
  }
}

// 统一错误处理中间件
function errorHandler(err, req, res, next) {
  console.error('API错误:', err)

  // 设置状态码
  const statusCode = err.statusCode || 500

  // 构建错误响应
  const errorResponse = {
    error: err.message || '服务器内部错误',
    status: statusCode
  }

  // 在开发环境中添加堆栈跟踪
  if (process.env.NODE_ENV !== 'production') {
    errorResponse.stack = err.stack
  }

  res.status(statusCode).json(errorResponse)
}

// API前缀
const API_PREFIX = '/api'

// 获取单个模型
app.get(`${API_PREFIX}/models/:name`, async (req, res, next) => {
  try {
    const { name } = req.params

    // 从数据库中查找模型
    const model = await Model.findOne({ where: { name } })

    if (!model) {
      const error = new Error('模型不存在')
      error.statusCode = 404
      throw error
    }

    // 返回模型数据
    res.json(model)
  } catch (error) {
    // 设置适当的状态码
    error.statusCode = error.statusCode || 500
    next(error)
  }
})

// 获取所有模型
app.get(`${API_PREFIX}/models`, async (req, res, next) => {
  try {
    const models = await Model.findAll()
    res.json(models)
  } catch (error) {
    error.statusCode = error.statusCode || 500
    next(error)
  }
})

app.get(`${API_PREFIX}/models/:id`, async (req, res, next) => {
  try {

    const { id } = req.params
    console.log(`获取模型: ${name}`)

    const model = await Model.findOne({ where: { id } })
    if (!model) {
      const error = new Error('模型不存在')
      error.statusCode = 404
      throw error
    }

    res.json(model)
  } catch (error) {
    next(error)
  }
})

app.post(`${API_PREFIX}/models`, async (req, res, next) => {
  try {
    console.log('创建模型请求:', req.body)

    // 验证请求数据
    const { name, displayName, fields } = req.body

    if (!name) {
      const error = new Error('模型名称不能为空')
      error.statusCode = 400
      throw error
    }

    if (!displayName) {
      const error = new Error('显示名称不能为空')
      error.statusCode = 400
      throw error
    }

    if (!Array.isArray(fields) || fields.length === 0) {
      const error = new Error('字段定义不能为空')
      error.statusCode = 400
      throw error
    }

    // 验证字段名称
    const fieldNames = new Set()
    for (const field of fields) {
      if (!field.name) {
        const error = new Error('字段名称不能为空')
        error.statusCode = 400
        throw error
      }

      if (fieldNames.has(field.name)) {
        const error = new Error(`字段名称 "${field.name}" 重复`)
        error.statusCode = 400
        throw error
      }

      fieldNames.add(field.name)
    }

    // 检查模型名称是否已存在
    const existingModel = await Model.findOne({ where: { name } })
    if (existingModel) {
      const error = new Error('模型名称已存在')
      error.statusCode = 400
      throw error
    }

    try {
      // 创建模型记录
      console.log('创建模型记录...')
      const model = await Model.create(req.body)
      console.log('模型记录创建成功:', model.id)

      try {
        // 创建并同步动态模型
        console.log('创建并同步动态模型...')
        await createAndSyncDynamicModel(model)
        console.log('动态模型创建并同步成功')

        res.status(201).json(model)
      } catch (syncError) {
        // 如果同步失败，删除已创建的模型记录
        console.error('动态模型创建失败，正在回滚...', syncError)
        await Model.destroy({ where: { id: model.id } })
        throw syncError
      }
    } catch (error) {
      console.error('创建模型失败:', error)
      // 如果是数据库锁定错误，返回特定的错误信息
      if (error.message.includes('SQLITE_BUSY')) {
        const customError = new Error('数据库正忙，请稍后重试')
        customError.statusCode = 503
        throw customError
      }
      throw error
    }
  } catch (error) {
    // 设置适当的状态码
    error.statusCode = error.statusCode || 500
    next(error)
  }
})

// 更新模型接口
app.put('/api/models/:name', async (req, res) => {
  try {
    console.log('PUT /api/models/:name - 开始处理 - IP:', req.ip);
    console.log('请求体:', req.body);

    const modelName = req.params.name;
    console.log('更新模型:', modelName);

    // 使用 name 字段而不是 id 来查找模型
    const model = await Model.findOne({
      where: {
        name: modelName
      }
    });

    if (!model) {
      // 如果模型不存在，创建新模型
      const newModel = await Model.create({
        name: req.body.name,
        displayName: req.body.displayName,
        description: req.body.description,
        fields: req.body.fields
      });

      res.json({
        success: true,
        model: newModel,
        message: '模型创建成功'
      });
    } else {
      // 如果模型存在，更新它
      await model.update({
        displayName: req.body.displayName,
        description: req.body.description,
        fields: req.body.fields
      });

      res.json({
        success: true,
        model: model,
        message: '模型更新成功'
      });
    }
  } catch (error) {
    console.error('更新模型失败:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '更新模型失败'
    });
  }
});

app.delete(`${API_PREFIX}/models/:id`, async (req, res, next) => {
  try {
    const { id } = req.params

    // 查找模型
    const model = await Model.findByPk(id)
    if (!model) {
      return res.status(404).json({
        error: '模型不存在',
        code: 'MODEL_NOT_FOUND'
      })
    }

    // 获取动态模型
    const dynamicModel = dynamicModels[model.name]
    if (!dynamicModel) {
      return res.status(404).json({
        error: '动态模型不存在',
        code: 'DYNAMIC_MODEL_NOT_FOUND'
      })
    }

    // 检查表中是否存在数据
    const count = await dynamicModel.count()
    if (count > 0) {
      return res.status(400).json({
        error: `模型 "${model.displayName || model.name}" 中存在 ${count} 条数据`,
        code: 'MODEL_HAS_DATA',
        count: count,
        message: '请先清空表中数据后再删除模型'
      })
    }

    // 如果没有数据，执行删除操作
    try {
      // 删除表
      await dynamicModel.drop()
      console.log(`表 ${model.name} 删除成功`)

      // 删除模型记录
      await model.destroy()
      console.log(`模型记录 ${model.name} 删除成功`)

      // 从动态模型缓存中移除
      delete dynamicModels[model.name]

      return res.json({
        message: '模型删除成功',
        code: 'MODEL_DELETED'
      })
    } catch (err) {
      console.error(`删除模型失败:`, err)
      return res.status(500).json({
        error: '删除模型失败',
        code: 'DELETE_FAILED',
        message: '服务器内部错误'
      })
    }
  } catch (error) {
    console.error('删除模型时发生错误:', error)
    return res.status(500).json({
      error: '服务器内部错误',
      code: 'INTERNAL_ERROR'
    })
  }
})

// 获取单个模型信息
app.get(`${API_PREFIX}/models/:name`, async (req, res, next) => {
  try {
    const { name } = req.params

    // 从数据库中查找模型定义
    const model = await Model.findOne({
      where: { name },
    })

    if (!model) {
      const error = new Error('模型不存在')
      error.statusCode = 404
      throw error
    }

    // 获取动态模型的表结构信息
    const dynamicModel = dynamicModels[name]
    if (!dynamicModel) {
      const error = new Error('动态模型不存在')
      error.statusCode = 404
      throw error
    }

    // 返回模型信息
    res.json({
      ...model.toJSON(),
      attributes: dynamicModel.rawAttributes
    })

  } catch (error) {
    console.error('获取模型信息失败:', error)
    next(error)
  }
})

// 定义JWT密钥常量，确保一致性
const JWT_SECRET = process.env.JWT_SECRET || 'dev-secret-key-change-in-production';

//token 登陆获取

app.post(`${API_PREFIX}/auth/login`, async (req, res) => {
  if (!(await hasUserTable(sequelize))) {
    return res.status(400).json({
      error: 'USER_TABLE_NOT_FOUND',
      message: '未检测到 User 表，请先在模型管理中创建 User 表（或同步数据库结构）后再尝试登录。'
    });
  }
  const { username, password } = req.body;
  console.log('登录请求:', { username, password });
  
  try {
    const dynamicModel = dynamicModels['User']
    if (!dynamicModel) {
      return res.status(500).json({
        error: 'USER_MODEL_NOT_FOUND',
        message: '用户模型未找到'
      });
    }
    
    const user = await dynamicModel.findOne({ where: { username } });
    if (!user) {
      return res.status(401).json({ 
        error: 'USER_NOT_FOUND',
        message: '用户名不存在'
      });
    }
    
    // 验证密码
    if (decryptPassword(user.password) !== password) {
      return res.status(401).json({ 
        error: 'INVALID_CREDENTIALS',
        message: '密码错误'
      });
    }
    
    // 获取客户端IP
    const clientIp = getClientIP(req);
    console.log('登录用户IP:', clientIp);
    
    // 生成 token，写入用户ID和IP
    const token = jwt.sign(
      { 
        uid: user.id, 
        ip: clientIp,
        username: user.username,
        loginTime: new Date().toISOString()
      },
      JWT_SECRET,  // 使用统一的密钥
      { expiresIn: '8h' }
    );
    
    console.log('登录成功，生成token:', {
      userId: user.id,
      username: user.username,
      clientIP: clientIp,
      tokenExpiry: '8h'
    });
    
    res.json({ 
      success: true,
      token, 
      user,
      message: '登录成功'
    });
  } catch (error) {
    console.error('登录失败:', error);
    res.status(500).json({
      error: 'LOGIN_FAILED',
      message: '登录过程中发生错误'
    });
  }
});

// 开发模式注释授权toekn
app.use('/api', authMiddleware);


// 获取数据列表
app.get(`${API_PREFIX}/data/:model`, async (req, res) => {
  try {
    const { model } = req.params
    let pages = 1
    let pageSize = 10
    let wheres = {}
    if (req.query.where) {
      wheres = req.query.where
    }
    if (req.query.page) { pages = req.query.page }
    if (req.query.pageSize) {
      pageSize = req.query.pageSize
    }
    console.log(pages, pageSize)
    const { page = pages, limit = pageSize, sort, order, ...filters } = req.query

    console.log(`获取 ${model} 数据，页码: ${page}, 每页: ${limit}, 排序: ${sort} ${order}`)
    console.log('过滤条件:', filters)

    // 检查模型是否存在
    if (!dynamicModels[model]) {
      try {
        // 尝试加载模型
        const [models] = await sequelize.query(`
          SELECT id, name, description, fields, createdAt, updatedAt,
          COALESCE(displayName, name) as displayName, 
          COALESCE(label, displayName, name) as label 
          FROM Models WHERE name = ?;
        `, {
          replacements: [model]
        })

        if (!models || models.length === 0) {
          return res.status(404).json({ error: `模型 "${model}" 不存在` })
        }

        const modelDef = models[0]

        // 解析 fields 字段
        if (typeof modelDef.fields === 'string') {
          modelDef.fields = JSON.parse(modelDef.fields)
        }

        await createAndSyncDynamicModel(modelDef)
      } catch (err) {
        console.error(`加载模型 "${model}" 失败:`, err)
        return res.status(500).json({ error: `加载模型失败: ${err.message}` })
      }

      if (!dynamicModels[model]) {
        return res.status(404).json({ error: `模型 "${model}" 不存在` })
      }
    }

    const dynamicModel = dynamicModels[model]

    // 构建查询条件
    const where = {}

    // 处理过滤条件
    for (const key in filters) {
      if (key.startsWith('filter_')) {
        const fieldName = key.replace('filter_', '')
        where[fieldName] = filters[key]
      }
    }
    if (wheres) {
      if (wheres) {
        Object.assign(where, wheres); // 正确地合并条件
      }
    }
    //console.log(where)
    // 构建排序
    const orderOptions = []
    if (sort) {
      orderOptions.push([sort, order === 'desc' ? 'DESC' : 'ASC'])
    } else {
      // 默认按 id 降序排序
      orderOptions.push(['id', 'DESC'])
    }

    // 解析分页参数，确保是数字
    const pageNum = parseInt(page, 10) || 1
    const limitNum = parseInt(limit, 10) || 10

    console.log(`查询参数: 页码=${pageNum}, 每页=${limitNum}, 排序=${JSON.stringify(orderOptions)}, 条件=${JSON.stringify(where)}`)

    // 查询数据
    const offset = (pageNum - 1) * limitNum

    // 使用 findAndCountAll 获取总数和分页数据
    const result = await dynamicModel.findAndCountAll({
      where,
      order: orderOptions,
      limit: limitNum,
      offset: offset
    })

    console.log(`查询结果: 总数=${result.count}, 当前页记录数=${result.rows.length}`)

    return res.json({
      records: result.rows,
      total: result.count,
      page: pageNum,
      limit: limitNum
    })
  } catch (error) {
    console.error('获取数据失败:', error)
    return res.status(500).json({ error: `获取数据失败: ${error.message}` })
  }
})

// 获取单条数据
app.get(`${API_PREFIX}/data/:modelName/:id`, async (req, res, next) => {
  try {
    const { modelName, id } = req.params

    // 设置响应超时时间
    req.setTimeout(30000) // 30秒超时
    res.setTimeout(30000)

    // 获取模型定义
    const model = await Model.findOne({
      where: { name: modelName },
      // 添加超时选项
      timeout: 5000
    })

    if (!model) {
      return res.status(404).json({
        error: '模型不存在',
        code: 'MODEL_NOT_FOUND'
      })
    }

    // 获取动态模型
    const dynamicModel = dynamicModels[modelName]
    if (!dynamicModel) {
      return res.status(404).json({
        error: '动态模型不存在',
        code: 'DYNAMIC_MODEL_NOT_FOUND'
      })
    }

    // 查询数据，添加错误处理和超时
    try {
      const data = await dynamicModel.findByPk(id, {
        timeout: 5000,
        // 添加事务隔离级别
        isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
      })

      if (!data) {
        return res.status(404).json({
          error: '数据不存在',
          code: 'DATA_NOT_FOUND'
        })
      }

      // 确保响应被正确发送
      res.json(data)
    } catch (queryError) {
      console.error('查询数据失败:', queryError)
      return res.status(500).json({
        error: '查询数据失败',
        message: queryError.message,
        code: 'QUERY_FAILED'
      })
    }
  } catch (error) {
    console.error('获取数据失败:', error)
    // 确保错误响应被发送
    if (!res.headersSent) {
      return res.status(500).json({
        error: '服务器内部错误',
        message: error.message,
        code: 'INTERNAL_ERROR'
      })
    }
  }
})

// 简化单条记录查询
app.get(`${API_PREFIX}/data/:model/:id`, async (req, res, next) => {
  try {
    const { model: modelName, id } = req.params

    // 简单的SQL查询
    const sql = `SELECT * FROM ${modelName} WHERE id = ${id} LIMIT 1`

    // 直接执行SQL查询
    const [rows] = await sequelize.query(sql, {
      type: sequelize.QueryTypes.SELECT,
      raw: true,
      logging: false
    })

    if (!rows || rows.length === 0) {
      return res.status(404).json({ error: '记录不存在' })
    }

    // 直接返回第一条记录
    res.json(rows[0])
  } catch (error) {
    console.error('记录查询失败:', error.message)
    res.status(500).json({ error: '记录查询失败' })
  }
})

// 添加全局错误处理中间件
app.use((err, req, res, next) => {
  console.error('全局错误处理:', err);

  // 设置状态码
  const statusCode = err.statusCode || 500;

  // 构建错误响应
  const errorResponse = {
    error: err.message || '服务器内部错误',
    status: statusCode,
    path: req.path,
    timestamp: new Date().toISOString()
  };

  // 在开发环境中添加堆栈信息
  if (process.env.NODE_ENV !== 'production') {
    errorResponse.stack = err.stack;
  }

  // 发送错误响应
  res.status(statusCode).json(errorResponse);
});

// 添加 GUID 生成函数
function generateGUID() {
  return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}

// 修改创建记录的路由
app.post(`${API_PREFIX}/data/:model`, async (req, res) => {
  const maxRetries = 5;
  let retryCount = 0;

  async function attemptCreate() {
    try {
      const { model: modelName } = req.params;

      // 检查请求体是否为空
      if (!req.body || Object.keys(req.body).length === 0) {
        return res.status(400).json({ error: '请求数据不能为空' });
      }

      // 生成32位GUID
      const guid = generateGUID();
      console.log(`生成新的GUID: ${guid}`);

      // 使用事务来确保数据一致性
      const result = await sequelize.transaction(async (t) => {
        // 检查动态模型是否存在
        const modelDef = await Model.findOne({
          where: { name: modelName },
          transaction: t
        });

        if (!modelDef) {
          throw new Error(`模型 "${modelName}" 不存在`);
        }

        // 确保modelDef.fields是数组
        let fields = []
        try {
          if (Array.isArray(modelDef.fields)) {
            fields = modelDef.fields
          } else if (typeof modelDef.fields === 'string') {
            fields = JSON.parse(modelDef.fields)
          }

          console.log(`解析后的字段:`, fields)
        } catch (err) {
          console.error(`解析${modelName}模型字段失败:`, err)
          fields = []
        }

        // 验证必填字段
        const requiredFields = fields.filter(f => f.required).map(f => f.name)
        console.log(`必填字段:`, requiredFields)

        for (const field of requiredFields) {
          if (req.body[field] === undefined || req.body[field] === null || req.body[field] === '') {
            throw new Error(`字段 "${field}" 不能为空`)
          }
        }

        // 检查动态模型是否存在
        if (!dynamicModels[modelName]) {
          console.log(`动态模型不存在，尝试创建:`, modelName)

          // 尝试重新加载模型
          try {
            await createAndSyncDynamicModel(modelDef)
          } catch (err) {
            console.error(`创建动态模型失败:`, err)
            throw err
          }

          if (!dynamicModels[modelName]) {
            throw new Error(`无法创建模型 "${modelName}" 的数据表`)
          }
        }

        // 创建记录
        const model = dynamicModels[modelName]
        console.log(`使用模型创建记录:`, modelName)

        // 处理数据，确保类型正确
        const processedData = {
          id: guid,  // 自动添加生成的GUID
        }

        // 处理请求中的字段
        for (const key in req.body) {
          // 查找字段定义
          const fieldDef = fields.find(f => f.name === key)
          if (fieldDef) {
            // 根据字段类型处理值
            switch (fieldDef.type) {
              case 'integer':
                processedData[key] = parseInt(req.body[key]) || 0
                break
              case 'number':
              case 'float':
                processedData[key] = parseFloat(req.body[key]) || 0
                break
              case 'boolean':
                processedData[key] = req.body[key] === 'true' || req.body[key] === true
                break
              default:
                processedData[key] = req.body[key]
            }
          } else {
            // 没有字段定义，保持原值
            processedData[key] = req.body[key]
          }
        }
        processedData["id"] = guid;
        console.log(`处理后的数据:`, processedData);

        const record = await model.create(processedData, {
          transaction: t,
          lock: t.LOCK.UPDATE
        });

        console.log(`记录创建成功:`, record.toJSON());
        return record;
      }, {
        isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
      });

      console.log(`记录创建成功，ID: ${result.id}`);
      return res.status(201).json(result);

    } catch (error) {
      // 检查是否是数据库锁定错误
      if ((error.message.includes('SQLITE_BUSY') ||
        error.message.includes('SQLITE_LOCKED')) &&
        retryCount < maxRetries) {

        retryCount++;
        const delay = Math.min(100 * Math.pow(2, retryCount), 2000); // 指数退避策略

        console.log(`数据库忙，第 ${retryCount} 次重试，等待 ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));

        return attemptCreate(); // 递归重试
      }

      // 如果不是锁定错误或已超过重试次数，则返回错误
      console.error('创建记录失败:', error);

      if (error.name === 'SequelizeValidationError') {
        return res.status(400).json({
          error: `数据验证失败: ${error.errors.map(e => e.message).join(', ')}`
        });
      } else if (error.name === 'SequelizeUniqueConstraintError') {
        return res.status(409).json({
          error: `数据已存在: ${error.errors.map(e => e.message).join(', ')}`
        });
      } else {
        return res.status(500).json({
          error: `创建记录失败: ${error.message}`,
          retryCount
        });
      }
    }
  }

  return attemptCreate();
});

// 更新数据
app.put(`${API_PREFIX}/data/:modelName/:id`, async (req, res, next) => {
  try {
    const { modelName, id } = req.params
    const updateData = req.body

    console.log('更新请求参数:', {
      modelName,
      id,
      updateData
    })

    // 获取模型定义 - 修复 findByPk 的使用
    const model = await Model.findOne({
      where: { name: modelName }
    })

    if (!model) {
      console.log(`模型 ${modelName} 不存在`)
      return res.status(404).json({
        error: '模型不存在',
        code: 'MODEL_NOT_FOUND'
      })
    }

    // 获取动态模型
    const dynamicModel = dynamicModels[modelName]
    if (!dynamicModel) {
      console.log(`动态模型 ${modelName} 不存在`)
      return res.status(404).json({
        error: '动态模型不存在',
        code: 'DYNAMIC_MODEL_NOT_FOUND'
      })
    }

    // 查找要更新的数据 - 直接传入 id 值
    const data = await dynamicModel.findByPk(id)
    if (!data) {
      console.log(`数据记录 ${id} 不存在`)
      return res.status(404).json({
        error: '数据不存在',
        code: 'DATA_NOT_FOUND'
      })
    }

    // 更新数据 - 使用 update 方法而不是 save
    await data.update(updateData)

    // 返回更新后的数据
    const updatedData = await dynamicModel.findByPk(id)
    console.log('更新成功:', updatedData.toJSON())
    res.json(updatedData)
  } catch (error) {
    console.error('更新数据失败:', error)
    next(error)
  }
})

app.delete(`${API_PREFIX}/data/:model/:id`, async (req, res, next) => {
  try {
    const { model: modelName, id } = req.params
    console.log(`删除${modelName}记录: ${id}`)

    // 检查动态模型是否存在
    if (!dynamicModels[modelName]) {
      // 尝试重新加载模型
      const modelDef = await Model.findOne({ where: { name: modelName } })
      if (modelDef) {
        await createAndSyncDynamicModel(modelDef)
      } else {
        const error = new Error('模型不存在')
        error.statusCode = 404
        throw error
      }
    }

    const model = dynamicModels[modelName]
    const record = await model.findByPk(id)

    if (!record) {
      const error = new Error('记录不存在')
      error.statusCode = 404
      throw error
    }

    await record.destroy()
    res.status(204).send()
  } catch (error) {
    next(error)
  }
})

// 系统设置API
// app.get('${API_PREFIX}/settings', (req, res) => {
//   res.json(config);
// });

// app.post('${API_PREFIX}/settings', (req, res) => {
//   config = req.body;
//   res.json(config);
// });

app.post('/api/settings/test-connection', async (req, res) => {
  try {
    const { databaseType, databaseConfig } = req.body
    let testSequelize

    switch (databaseType) {
      case 'mysql':
        testSequelize = new Sequelize(
          databaseConfig.mysql.database,
          databaseConfig.mysql.username,
          databaseConfig.mysql.password,
          {
            host: databaseConfig.mysql.host,
            port: databaseConfig.mysql.port,
            dialect: 'mysql'
          }
        )
        break
      case 'sqlserver':
        testSequelize = new Sequelize(
          databaseConfig.sqlserver.database,
          databaseConfig.sqlserver.user,
          databaseConfig.sqlserver.password,
          {
            host: databaseConfig.sqlserver.server,
            port: databaseConfig.sqlserver.port,
            dialect: 'mssql'
          }
        )
        break
      case 'sqlite':
      default:
        testSequelize = new Sequelize({
          dialect: 'sqlite',
          storage: databaseConfig.sqlite.storage
        })
        break
    }

    await testSequelize.authenticate()
    res.json({ success: true, message: '连接成功' })
  } catch (error) {
    res.status(500).json({ success: false, message: `连接失败: ${error.message}` })
  }
})

// 添加服务器状态API
app.get('/api/status', (req, res) => {
  res.json({
    status: 'running',
    time: new Date().toISOString(),
    uptime: process.uptime(),
    memory: process.memoryUsage()
  });
});

// 添加一个简单的测试路由
app.get(`${API_PREFIX}/ping`, (req, res) => {
  res.json({ message: 'pong', time: new Date().toISOString() })
})

// 获取本机所有可访问的IP地址和URL
function getServerUrls(port) {
  const networkInterfaces = os.networkInterfaces();
  const urls = new Set();

  // 添加localhost
  urls.add(`http://localhost:${port}`);

  // 添加所有网络接口的IP
  Object.values(networkInterfaces).forEach(interfaces => {
    interfaces.forEach(iface => {
      // 只添加IPv4地址且非内部地址
      if (iface.family === 'IPv4' && !iface.internal) {
        urls.add(`http://${iface.address}:${port}`);
      }
    });
  });

  return Array.from(urls);
}

// 启动服务器
const PORT = process.env.PORT || 3000

// 初始化并启动
async function start() {
  try {
    await initDatabase();
    await loadModels();

    // 初始化IP授权状态
    await initializeAuthStatus();

    app.listen(PORT, '0.0.0.0', () => {
      const serverUrls = getServerUrls(PORT);

      console.log('\n=== 后端服务器已启动 ===');
      console.log('可通过以下地址访问:');
      serverUrls.forEach(url => {
        console.log(`- ${url}`);
      });
      console.log(`\nAPI前缀: ${API_PREFIX}`);
      console.log(`模型API路径: ${API_PREFIX}/models`);
      console.log(`数据库类型: ${config.databaseType}`);
      console.log(`已授权IP数量: ${authorizedIPCache.size}`);
      console.log('=========================\n');
    });
  } catch (error) {
    console.error('服务器启动失败:', error);
    process.exit(1);
  }
}

start()

// 添加测试接口
app.get('${API_PREFIX}/auth/test-ip/:ip', async (req, res) => {
  const { ip } = req.params;

  try {
    const authorizedIP = await AuthorizedIP.findOne({
      where: {
        ip,
        enabled: true
      }
    });

    res.json({
      ip,
      authorized: !!authorizedIP,
      details: authorizedIP || null,
      isLocal: getLocalIPs().has(ip)
    });
  } catch (error) {
    res.status(500).json({
      error: '检查IP失败',
      message: error.message
    });
  }
});

// 添加IP授权测试接口
app.get('${API_PREFIX}/auth/check-status', async (req, res) => {
  const clientIP = req.headers['x-forwarded-for']?.split(',')[0]?.trim() ||
    req.headers['x-real-ip'] ||
    req.connection.remoteAddress ||
    req.ip;

  try {
    const authorizedIP = await AuthorizedIP.findOne({
      where: {
        ip: clientIP
      }
    });

    res.json({
      ip: clientIP,
      status: {
        isAuthorized: !!authorizedIP,
        isEnabled: authorizedIP?.enabled ?? false,
        lastAccess: authorizedIP?.lastAccess,
        description: authorizedIP?.description
      },
      message: authorizedIP?.enabled
        ? '您的IP已授权可以访问'
        : (authorizedIP
          ? '您的IP已被禁用'
          : '您的IP未授权')
    });
  } catch (error) {
    console.error('检查IP状态失败:', error);
    res.status(500).json({
      error: '检查IP状态失败',
      message: error.message
    });
  }
});

// 文件上传相关API
// 单文件上传
app.post('/api/upload/single', upload.single('file'), async (req, res) => {
  try {
    console.log('文件上传请求头:', req.headers);
    console.log('请求体:', req.body);
    console.log('上传的文件:', req.file);

    if (!req.file) {
      console.log('没有文件被上传，返回400错误');
      return res.status(400).json({
        success: false,
        error: '没有文件被上传'
      });
    }

    const file = req.file;

    // 根据文件类型生成正确的文件类型目录
    let fileType = 'other'
    if (file.mimetype.startsWith('image/')) {
      fileType = 'image'
    } else if (file.mimetype.startsWith('application/')) {
      fileType = 'application'
    } else if (file.mimetype.startsWith('text/')) {
      fileType = 'text'
    } else if (file.mimetype.startsWith('video/')) {
      fileType = 'video'
    } else if (file.mimetype.startsWith('audio/')) {
      fileType = 'audio'
    }

    const fileUrl = `/uploads/${fileType}/${file.filename}`;

    console.log(`文件上传成功: ${file.originalname} -> ${file.path}`);
    console.log(`文件类型: ${file.mimetype}, 分类目录: ${fileType}`);

    res.json({
      success: true,
      message: '文件上传成功',
      data: {
        originalName: file.originalname,
        filename: file.filename,
        mimetype: file.mimetype,
        size: file.size,
        path: file.path,
        url: fileUrl,
        fileType: fileType
      }
    });
  } catch (error) {
    console.error('文件上传失败:', error);
    res.status(500).json({
      success: false,
      error: '文件上传失败',
      message: error.message
    });
  }
});

// 多文件上传
app.post('/api/upload/multiple', upload.array('files', 10), async (req, res) => {
  try {
    console.log('多文件上传请求头:', req.headers);
    console.log('请求体:', req.body);
    console.log('上传的文件:', req.files);

    if (!req.files || req.files.length === 0) {
      console.log('没有文件被上传，返回400错误');
      return res.status(400).json({
        success: false,
        error: '没有文件被上传'
      });
    }

    const uploadedFiles = req.files.map(file => {
      // 根据文件类型生成正确的文件类型目录
      let fileType = 'other'
      if (file.mimetype.startsWith('image/')) {
        fileType = 'image'
      } else if (file.mimetype.startsWith('application/')) {
        fileType = 'application'
      } else if (file.mimetype.startsWith('text/')) {
        fileType = 'text'
      } else if (file.mimetype.startsWith('video/')) {
        fileType = 'video'
      } else if (file.mimetype.startsWith('audio/')) {
        fileType = 'audio'
      }

      const fileUrl = `/uploads/${fileType}/${file.filename}`;
      return {
        originalName: file.originalname,
        filename: file.filename,
        mimetype: file.mimetype,
        size: file.size,
        path: file.path,
        url: fileUrl,
        fileType: fileType
      };
    });

    console.log(`批量文件上传成功: ${uploadedFiles.length} 个文件`);

    res.json({
      success: true,
      message: `成功上传 ${uploadedFiles.length} 个文件`,
      data: uploadedFiles
    });
  } catch (error) {
    console.error('批量文件上传失败:', error);
    res.status(500).json({
      success: false,
      error: '批量文件上传失败',
      message: error.message
    });
  }
});

// 获取文件列表
app.get('/api/upload/files', async (req, res) => {
  try {
    const { type, page = 1, limit = 20 } = req.query;
    const pageNum = parseInt(page, 10);
    const limitNum = parseInt(limit, 10);

    let files = [];
    const allTypes = ['image', 'application', 'text'];

    if (type && allTypes.includes(type)) {
      // 获取特定类型的文件
      const typeDir = path.join(UPLOAD_DIR, type);
      if (fs.existsSync(typeDir)) {
        files = await getFilesFromDirectory(typeDir, type);
      }
    } else {
      // 获取所有类型的文件
      for (const fileType of allTypes) {
        const typeDir = path.join(UPLOAD_DIR, fileType);
        if (fs.existsSync(typeDir)) {
          const typeFiles = await getFilesFromDirectory(typeDir, fileType);
          files = files.concat(typeFiles);
        }
      }
    }

    // 按修改时间排序
    files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());

    // 分页
    const total = files.length;
    const start = (pageNum - 1) * limitNum;
    const end = start + limitNum;
    const paginatedFiles = files.slice(start, end);

    res.json({
      success: true,
      data: {
        files: paginatedFiles,
        pagination: {
          page: pageNum,
          limit: limitNum,
          total,
          pages: Math.ceil(total / limitNum)
        }
      }
    });
  } catch (error) {
    console.error('获取文件列表失败:', error);
    res.status(500).json({
      success: false,
      error: '获取文件列表失败',
      message: error.message
    });
  }
});

// 删除文件
app.delete('/api/upload/files/:filename', async (req, res) => {
  try {
    const { filename } = req.params;
    const { type } = req.query;

    if (!type) {
      return res.status(400).json({
        success: false,
        error: '缺少文件类型参数'
      });
    }

    const filePath = path.join(UPLOAD_DIR, type, filename);

    if (!fs.existsSync(filePath)) {
      return res.status(404).json({
        success: false,
        error: '文件不存在'
      });
    }

    // 删除文件
    fs.unlinkSync(filePath);

    console.log(`文件删除成功: ${filePath}`);

    res.json({
      success: true,
      message: '文件删除成功'
    });
  } catch (error) {
    console.error('删除文件失败:', error);
    res.status(500).json({
      success: false,
      error: '删除文件失败',
      message: error.message
    });
  }
});

// 获取文件信息
app.get('/api/upload/files/:filename/info', async (req, res) => {
  try {
    const { filename } = req.params;
    const { type } = req.query;

    if (!type) {
      return res.status(400).json({
        success: false,
        error: '缺少文件类型参数'
      });
    }

    const filePath = path.join(UPLOAD_DIR, type, filename);

    if (!fs.existsSync(filePath)) {
      return res.status(404).json({
        success: false,
        error: '文件不存在'
      });
    }

    const stats = fs.statSync(filePath);
    const fileUrl = `/uploads/${type}/${filename}`;

    res.json({
      success: true,
      data: {
        filename,
        type,
        size: stats.size,
        mtime: stats.mtime,
        ctime: stats.ctime,
        url: fileUrl,
        path: filePath
      }
    });
  } catch (error) {
    console.error('获取文件信息失败:', error);
    res.status(500).json({
      success: false,
      error: '获取文件信息失败',
      message: error.message
    });
  }
});

// 文件下载API - 确保文件能正确下载
app.get('/api/upload/download/:filename', async (req, res) => {
  try {
    const { filename } = req.params;
    const { type } = req.query;

    if (!type) {
      return res.status(400).json({
        success: false,
        error: '缺少文件类型参数'
      });
    }

    const filePath = path.join(UPLOAD_DIR, type, filename);

    if (!fs.existsSync(filePath)) {
      return res.status(404).json({
        success: false,
        error: '文件不存在'
      });
    }

    const stats = fs.statSync(filePath);
    const ext = path.extname(filename).toLowerCase();

    // 设置正确的MIME类型
    const mimeTypes = {
      '.pdf': 'application/pdf',
      '.doc': 'application/msword',
      '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
      '.xls': 'application/vnd.ms-excel',
      '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
      '.txt': 'text/plain',
      '.csv': 'text/csv',
      '.zip': 'application/zip',
      '.rar': 'application/x-rar-compressed',
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.png': 'image/png',
      '.gif': 'image/gif',
      '.webp': 'image/webp'
    };

    const contentType = mimeTypes[ext] || 'application/octet-stream';

    // 设置响应头
    res.set({
      'Content-Type': contentType,
      'Content-Length': stats.size,
      'Content-Disposition': `attachment; filename="${encodeURIComponent(filename)}"`,
      'Cache-Control': 'no-cache'
    });

    // 创建文件流并发送
    const fileStream = fs.createReadStream(filePath);
    fileStream.pipe(res);

    console.log(`文件下载成功: ${filename} -> ${filePath}`);

  } catch (error) {
    console.error('文件下载失败:', error);
    res.status(500).json({
      success: false,
      error: '文件下载失败',
      message: error.message
    });
  }
});

// 辅助函数：从目录获取文件信息
async function getFilesFromDirectory(dirPath, fileType) {
  try {
    const files = fs.readdirSync(dirPath);
    const fileInfos = [];

    for (const file of files) {
      const filePath = path.join(dirPath, file);
      const stats = fs.statSync(filePath);

      if (stats.isFile()) {
        fileInfos.push({
          filename: file,
          type: fileType,
          size: stats.size,
          mtime: stats.mtime,
          ctime: stats.ctime,
          url: `/uploads/${fileType}/${file}`
        });
      }
    }

    return fileInfos;
  } catch (error) {
    console.error(`读取目录失败: ${dirPath}`, error);
    return [];
  }
}

// 文件上传错误处理中间件
app.use((error, req, res, next) => {
  console.error('全局错误处理中间件捕获到错误:', error);

  if (error instanceof multer.MulterError) {
    if (error.code === 'LIMIT_FILE_SIZE') {
      return res.status(400).json({
        success: false,
        error: '文件大小超出限制',
        message: `文件大小不能超过 ${MAX_FILE_SIZE / (1024 * 1024)}MB`
      });
    }
    if (error.code === 'LIMIT_FILE_COUNT') {
      return res.status(400).json({
        success: false,
        error: '文件数量超出限制',
        message: '最多只能上传10个文件'
      });
    }
    if (error.code === 'LIMIT_UNEXPECTED_FILE') {
      return res.status(400).json({
        success: false,
        error: '意外的文件字段',
        message: '请检查文件上传字段名'
      });
    }
  }

  // 处理其他类型的错误
  const statusCode = error.statusCode || 500;
  const message = error.message || '服务器内部错误';

  console.error(`错误详情 - 状态码: ${statusCode}, 消息: ${message}`);

  res.status(statusCode).json({
    success: false,
    error: '请求处理失败',
    message: message,
    ...(process.env.NODE_ENV === 'development' && { stack: error.stack })
  });
});


//登录扩展接口
// 假设使用 express + jsonwebtoken
app.set('trust proxy', true); // 重要：在反代后取真实IP

function getClientIP(req) {
  const xff = (req.headers['x-forwarded-for'] || '').split(',')[0].trim();
  return xff || req.ip || req.socket.remoteAddress;
}
function normalizeTableName(t) {
  if (!t) return '';
  if (typeof t === 'string') return t;
  return (t.tableName || t.name || '').toString();
}

async function hasUserTable(sequelize) {
  try {
    const qi = sequelize.getQueryInterface();
    const tables = await qi.showAllTables();
    return tables
      .map(normalizeTableName)
      .some(name => name && name.toLowerCase() === 'user'); // 注意大小写
  } catch (e) {
    return false;
  }
}

//



function authMiddleware(req, res, next) {
  // 放行所有认证相关路由（无论方法），避免因缺少 token 拦截登录/退出/获取资料
  if (process.env.CleintPort === '8003' || PORT === 8003) {
    console.log('开发调试模式（8003端口），跳过token验证');
    return next();
  }
  if (req.originalUrl && req.originalUrl.startsWith('/api/auth')||req.originalUrl.startsWith('/api/upload/download')) {
    return next();
  }
  
  // 兼容预检请求
  if (req.method === 'OPTIONS') {
    return next();
  }

  console.log('\n=== Token验证开始 ===');
  console.log('请求路径:', req.originalUrl);
  console.log('请求方法:', req.method);
  console.log('Authorization头:', req.headers.authorization);

  const auth = req.headers.authorization || '';
  const token = auth.startsWith('Bearer ') ? auth.slice(7) : null;
  
  if (!token) {
    console.log('Token验证失败: 缺少Authorization头');
    return res.status(401).json({ 
      error: 'NO_TOKEN',
      message: '缺少访问令牌，请先登录'
    });
  }

  try {
    console.log('开始验证JWT token...');
    
    // 验证JWT token
    const payload = jwt.verify(token, JWT_SECRET);
    console.log('JWT验证成功，payload:', payload);
    
    // 获取当前请求的IP
    const reqIp = getClientIP(req);
    console.log('当前请求IP:', reqIp);
    console.log('Token中的IP:', payload.ip);
    
    // 检查IP是否匹配
    if (payload.ip === reqIp) {
      console.log('IP验证成功，完全匹配');
      req.user = { 
        id: payload.uid,
        ip: payload.ip,
       
      };
      console.log('用户信息设置成功:', req.user);
      next();
    } else {
      // IP不匹配，检查是否是本地请求
      const isLocalRequest = isLocalIP(reqIp);
      console.log('IP不匹配，检查本地IP:', {
        requestIP: reqIp,
        tokenIP: payload.ip,
        isLocal: isLocalRequest
      });
      
      if (isLocalRequest) {
        console.log('本地IP请求，允许通过');
        req.user = { 
          id: payload.uid,
          ip: payload.ip,
          username: payload.username
        };
        next();
      } else {
        console.log('IP验证失败，拒绝访问');
        return res.status(401).json({ 
          error: 'TOKEN_IP_MISMATCH',
          message: '访问令牌与当前IP不匹配，请重新登录',
          details: {
            requestIP: reqIp,
            tokenIP: payload.ip
          }
        });
      }
    }
  } catch (e) {
    console.log('Token验证失败:', e.message);
    console.log('错误详情:', e);
    
    let errorMessage = '访问令牌无效';
    if (e.name === 'TokenExpiredError') {
      errorMessage = '访问令牌已过期，请重新登录';
    } else if (e.name === 'JsonWebTokenError') {
      errorMessage = '访问令牌格式错误';
    }
    
    return res.status(401).json({ 
      error: 'INVALID_TOKEN',
      message: errorMessage,
      details: e.message
    });
  }
}

// 保护需要登录的接口（将其放到所有 /api 路由前，确保优先生效）
